home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Development Tools & Languages / • Other Platforms / PCCTS 1.31 / lang / Pascal / pmain.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-10  |  3.2 KB  |  187 lines  |  [TEXT/MPS ]
  1. /*  Pascal grammar
  2.  *
  3.  */
  4.  
  5. #include <stdio.h>
  6. #ifdef __STDC__
  7. #include <stdlib.h>
  8. #else
  9. #include <malloc.h>
  10. #endif
  11. #include "stdpccts.h"
  12.  
  13. #define SymStrTable        10000
  14. #define HashSize        10001
  15.  
  16. struct _pre {
  17.     char *symbol;
  18.     int token;
  19. };
  20.  
  21. struct _pre predef[] = {
  22.     /* keywords */
  23.     { "and", And },
  24.     { "array", Array },
  25.     { "begin", Begin },
  26.     { "case", Case },
  27.     { "const", Const },
  28.     { "div", Div },
  29.     { "do", Do },
  30.     { "downto", Downto },
  31.     { "else", Else },
  32.     { "end", End },
  33.     { "file", File },
  34.     { "for", For },
  35.     { "forward", Forward },
  36.     { "function", Function },
  37.     { "goto", Goto },
  38.     { "if", If },
  39.     { "in", In },
  40.     { "label", Label },
  41.     { "mod", Mod },
  42.     { "nil", Nil },
  43.     { "not", Not },
  44.     { "of", Of },
  45.     { "or", Or },
  46.     { "packed", Packed },
  47.     { "procedure", Procedure },
  48.     { "program", Program },
  49.     { "record", Record },
  50.     { "repeat", Repeat },
  51.     { "set", Set },
  52.     { "then", Then },
  53.     { "to", To },
  54.     { "type", Type },
  55.     { "until", Until },
  56.     { "var", Var },
  57.     { "while", While },
  58.     { "with", With },
  59.  
  60.      /* Predefined Constants */
  61.     { "maxint", ConstID },
  62.     { "true", ConstID },
  63.     { "false", ConstID },
  64.  
  65.      /* Predefined Types */
  66.      {"real", TypeID},
  67.      {"boolean", TypeID},
  68.      {"char", TypeID},
  69.      {"integer", TypeID},
  70.      {"text", TypeID},
  71.  
  72.      /* Predefined Functions */
  73.      { "odd", FuncID },
  74.      { "eoln", FuncID },
  75.      { "eof", FuncID },
  76.      { "abs", FuncID },
  77.      { "sqr", FuncID },
  78.      { "sin", FuncID },
  79.      { "cos", FuncID },
  80.      { "arctan", FuncID },
  81.      { "ln", FuncID },
  82.      { "exp", FuncID },
  83.      { "sqrt", FuncID },
  84.      { "ord", FuncID },
  85.      { "chr", FuncID },
  86.      { "pred", FuncID },
  87.      { "succ", FuncID },
  88.      { "round", FuncID },
  89.      { "trunc", FuncID },
  90.  
  91.      /* Predefined Procedures */
  92.      { "put", ProcID },
  93.      { "get", ProcID },
  94.      { "reset", ProcID },
  95.      { "rewrite", ProcID },
  96.      { "new", ProcID },
  97.      { "dispose", ProcID },
  98.      { "read", ProcID },
  99.      { "readln", ProcID },
  100.      { "write", ProcID },
  101.      { "writeln", ProcID },
  102.      { "page", ProcID },
  103.  
  104.      {NULL, 0}
  105. };
  106.  
  107. main(argc, argv)
  108. int argc;
  109. char *argv[];
  110. {
  111.     Sym *p;
  112.     FILE *f;
  113.     
  114. /*    if ( argc==1 ) {fprintf(stderr, "Usage: pas filename\n"); return;} */
  115.     if ( argc==1 ){
  116.         f = stdin;
  117.     }else{
  118.         f = fopen(argv[1], "r");
  119.     }
  120.     if ( f==NULL ) {fprintf(stderr, "Can't Open '%s'\n", argv[1]); return;}
  121.  
  122.     zzs_init(HashSize, SymStrTable);
  123.     LoadSymTable();
  124.  
  125.     ANTLR(program(), f);        /* Parse program from stdin */
  126.     /*statsym();*/
  127.     /*print_trax();*/        /* list out the last rules applied */
  128.     exit(0);
  129. }
  130.  
  131. LoadSymTable()
  132. {
  133.     struct _pre *p = &(predef[0]);
  134.     Sym *sym;
  135.  
  136.     while ( p->symbol != NULL )
  137.     {
  138.         sym = zzs_newadd(p->symbol);
  139.         sym->token = p->token;
  140.         p++;
  141.     }
  142. }
  143.  
  144. /* converts a list of entries in symbol table into something else */
  145. addlist(list, token, level)
  146. Sym *list;
  147. int token, level;
  148. {
  149.     register Sym *p, *q;
  150.  
  151.     for (p=list; p!=NULL; p=q)
  152.     {
  153.         q = make_special_entry(token,p);
  154.         q->level = level;
  155.         q = p->link;
  156.         /* unlink things */
  157.         p->link = NULL;
  158.     }
  159. }
  160.  
  161. Sym *make_special_entry(token, p)
  162. int token;
  163. Sym *p;
  164. {
  165.     if (p){
  166.         switch(p->token){
  167.         case UTypeID:
  168.         case VarID:
  169.         case ProcID:
  170.         case ProgID:
  171.         case FuncID:
  172.         case ConstID:
  173.             /* need to make new entry for this scope */
  174.             p = zzs_newadd(p->symbol);
  175.         case WORD:
  176.         /* in this case can just use the symbol entry already made */
  177.             p->token = token;
  178.             break;
  179.         default:
  180.             fprintf(stderr,"Tried to redefine reserved word %s\n",
  181.                 p->symbol);
  182.             break;
  183.         }
  184.     }
  185.     return p;
  186. }
  187.